#ifndef __FILE__H__
#define  __FILE_H__



#include "pb.h"




/** Structure queue
 *  Permet de manipuler des suites de données de type Etat  définis  dans pb.h
 */ 

typedef struct queue {


  /** Reférence à la donnée 
   *
   */

  Etat *element;

   /** Reférence à  la cellule  suivante de la suite 
   *
   */ 
  
  struct queue *suivant;
  
}    Queue ;

/** Structure file
 *  Permet de créer le contexte pour manipuler les suites précédentes comme des files,
 *   c'est à dire comme des collection de données de type premier rentré, premier sorti
 *   ( En anglais First in, First out soit FIFO)
 *  La structure permet en outre  de manipuler des données statistiques intéressantes 
 *  telles que la longueur de la plus longue file  utilisée lors d'un calcul
 */ 


  
typedef struct file {

  /** Longueur  de la plus longue  file  utilisée lors d'un calcul */

  int LONGUEUR_MAX_FILE;

 /** Longueur  instantanée de la file   */

  int LONGUEUR_EFFECTIVE;

  /**  Le premier élément de la suite  */

  Queue * debut;

  /**  Le dernier élément de la suite  */

  Queue *fin;
}   File ;


/**  Procedure libererFile
 *   Libère la mémoire occupée par la File
 *   La mémoire occupée par la suite d'états est elle auusi libérée
 *   La mémoire correspondant aux états de la suite est libérée
 *   Cette dernière opération est effectuée par une procédure libérerEtat qui doit être fournie
 *   La signature de la procédure  doit être 
 *       void libererEtat(Etat *e);
 *
 *    Arguments 
 *         File *f : la file à libérer
 *
*/
void libererFile(File *f) ;


/**  Fonction  nouvelleFile
 *   Crée une nouvelle file vide
 * 
 *   Retourne:
 *              un pointeur sur la nouvelle file  
 */
File *nouvelleFile(void);

/**  Fonction  estVide
 *   Teste si la file est vide 
 *
 *   Paramètre:
 *              File *f: la file à tester 
 * 
 *   Retourne:
 *              O: si la file contient au moins un Etat
 *              1: si la file ne contient aucun Etat
 *
 *
 *   La signature forme de la fonction  est   
 *
 *            int estVide(File *f);
 * 
 *   L'implémentation effective est réalisé en utilisant une Macro.
 *   Ceci permet d'économiser un appel de fonction, tout en maintenant l'encapsulation.
 *
 */



#define estVide(f) ((f->LONGUEUR_EFFECTIVE == 0))


/**  Procedure  enfiler
 *   Ajoute un Etat à une File
 *
 *   Paramètres:
 *              File *f: la file dans laquelle on veut ajouter un Etat.
 *            
 *              Etat *e: L'Etat à ajouter. 
 * 
 *   
 */


void enfiler(File *f, Etat *e);


/**  Procedure  enfilerUnique
 *   Teste si un Etat est  présent dans la File.
 *   Ajoute cet élément s'il n'est pas déjà présent 
 *
 *   Paramètres:
 *              File *f: la file dans laquelle on veut ajouter un Etat.
 *            
 *              Probleme *p : Le problème qui définit le contexte de l'état à ajouter
 *
 *              Etat *e: L'Etat à ajouter. 
 * 
 *   La comparaison des etats dans le contexte d'un probleme donné est effectuée à l'aide d'une fonction   estEgal de signature 
 *
 *              int estEgal(Probleme *p, Etat *e1, Etat *e2);
 *
 *    Cette fonction doit être fournie avaec la définition des problèmes et des états. 
 */

 
void enfilerUnique(File *f, Probleme *p, Etat *e);


/**  Fonction  defiler
 *   Retire un Etat dans une file  
 *
 *   Paramètre:
 *              File *f: la file dont il faut retirer un Etat
 * 
 *   Retourne:
 *              Etat * : l'état retiré
 *
 */


Etat *defiler(File *f);


/**  Fonction  longueurMax
 *   Fournit la longueur de de la plus longue suite d'Etats manipulée en utilisant la File 
 *
 *   Paramètre:
 *              File *f: la file à étudier
 * 
 *   Retourne:
 *              Un entier : La longueur recherchée
 *              1: si la file ne contient aucun Etat
 *
 *
 *   La signature forme de la fonction  est   
 *
 *            int longueurMax(File *f);
 * 
 *   L'implémentation effective est réalisé en utilisant une Macro.
 *   Ceci permet d'économiser un appel de fonction, tout en maintenant l'encapsulation.
 *
 */


 
#define longueurMax(f) (( f)-> LONGUEUR_MAX_FILE)

#endif 
